// Copyright (c) 2024, BlockProject 3D

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without modification,

// are permitted provided that the following conditions are met:

//

//     * Redistributions of source code must retain the above copyright notice,

//       this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above copyright notice,

//       this list of conditions and the following disclaimer in the documentation

//       and/or other materials provided with the distribution.

//     * Neither the name of BlockProject 3D nor the names of its contributors

//       may be used to endorse or promote products derived from this software

//       without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use crate::api::config::model::Config;

use crate::api::core::generator::{Context, Generator, Params};

use crate::api::core::loader::{Loader, Options};

use crate::api::core::Error;

use crate::compiler::util::imports::ImportSolver;

use bp3d_debug::trace;

use serde::Deserialize;

use std::borrow::Cow;

use crate::compiler::util::protocols::ProtocolStore;

pub fn parse<'a, T: Deserialize<'a>>(data: &'a str) -> Result<Config<'a, T>, toml::de::Error> {

    toml::from_str(data)

}

pub fn compile<'a, 'b, T, I: ImportSolver>(config: &'b Config<T>, solver: &'a I) -> Result<ProtocolStore<'a, I, Options<'b>>, Error> {

    let mut loader = Loader::default();

    loader.load_from_folder(config.package.path, &Options::from_package(config.package.name))
?0
;

    if let Some(
deps1
) = &config.dependency {

  Branch (46:12): [True: 1, False: 1]

  Branch (46:12): [Folded - Ignored]

  Branch (46:12): [True: 0, False: 1]

  Branch (46:12): [Folded - Ignored]

        for 
dep1
 in deps {

            loader.load_from_file(dep.path, Options::from_package(dep.package).exclude_from_generation())
?0
;

        }

    }

    trace!("Excluded protocols: {:?}", config.package.exclude);

    if let Some(
excludes2
) = &config.package.exclude {

  Branch (52:12): [True: 1, False: 1]

  Branch (52:12): [Folded - Ignored]

  Branch (52:12): [True: 1, False: 0]

  Branch (52:12): [Folded - Ignored]

        for 
exclude2
 in excludes {

            loader.exclude(exclude);

        }

    }

    loader.compile(solver)

}

pub fn generate<'a, G: crate::gen::Generator, T, I: ImportSolver, F: Fn(&T) -> Option<G::Params<'_>>>(

    generator: &'a Generator<'a, G>,

    context: &mut Context<'a, I>,

    config: &Config<T>,

    generator_params_converter: F,

    generator_default_params: &G::Params<'_>,

) -> Result<(), Error> {

    if let Some(
options2
) = &config.options {

  Branch (67:12): [True: 2, False: 1]

  Branch (67:12): [True: 0, False: 0]

  Branch (67:12): [Folded - Ignored]

        for (
protocol, params12
) in options {

            let protocol_path: Cow<str> = if config.package.name.is_empty() {

  Branch (69:46): [True: 12, False: 0]

  Branch (69:46): [True: 0, False: 0]

  Branch (69:46): [Folded - Ignored]

                Cow::Borrowed(protocol)

            } else {

                Cow::Owned(format!("{}::{}", config.package.name, protocol))

            };

            trace!({ path = &*protocol_path }, "Found options for protocol: {}", protocol);

            let mut p = Params::default();

            if let Some(
flag1
) = params.write_messages {

  Branch (76:20): [True: 1, False: 11]

  Branch (76:20): [True: 0, False: 0]

  Branch (76:20): [Folded - Ignored]

                p.write_messages = flag;

            }

            if let Some(
flag1
) = params.read_messages {

  Branch (79:20): [True: 1, False: 11]

  Branch (79:20): [True: 0, False: 0]

  Branch (79:20): [Folded - Ignored]

                p.read_messages = flag;

            }

            if let Some(
flag0
) = params.use_enums {

  Branch (82:20): [True: 0, False: 12]

  Branch (82:20): [True: 0, False: 0]

  Branch (82:20): [Folded - Ignored]

                p.use_enums = flag;

            }

            if let Some(
flag0
) = params.use_structs {

  Branch (85:20): [True: 0, False: 12]

  Branch (85:20): [True: 0, False: 0]

  Branch (85:20): [Folded - Ignored]

                p.use_structs = flag;

            }

            if let Some(
flag0
) = params.use_unions {

  Branch (88:20): [True: 0, False: 12]

  Branch (88:20): [True: 0, False: 0]

  Branch (88:20): [Folded - Ignored]

                p.use_unions = flag;

            }

            if let Some(
flag0
) = params.use_messages {

  Branch (91:20): [True: 0, False: 12]

  Branch (91:20): [True: 0, False: 0]

  Branch (91:20): [Folded - Ignored]

                p.use_messages = flag;

            }

            if let Some(
gp11
) = generator_params_converter(&params.inner) {

  Branch (94:20): [True: 11, False: 1]

  Branch (94:20): [True: 0, False: 0]

  Branch (94:20): [Folded - Ignored]

                context.generate(generator, protocol_path, &p, &gp)
?0
;

            } else {

                context.generate(generator, protocol_path, &p, generator_default_params)
?0
;

            }

        }

    }

    let params = Params::default();

    context.generate_all(generator, &params, generator_default_params)

}